在 C++ 中，每个表达式的结果要么是 左值 ，要么是 右值。这一区别决定了表达式是指向对象的 身份 （它在哪里）还是其 值 （它包含的内容）。
1. 身份与内容
一个 左值 （定位值）表示具有持久内存地址的对象。可以将其想象为内存中的一个带标签的盒子。相反，一个 右值 （读值）是临时的；它代表一个临时结果或字面量，该字面量对程序员不可访问其地址。
2. 功能性转换
虽然左值可以作为右值使用（编译器只需获取盒子内的值），但反过来是被禁止的。你不能在需要左值的地方使用右值——例如，你无法对像 &42 这样的字面量取地址，因为它缺乏持久的身份。
$$ \text{左值} \xrightarrow{\text{转换}} \text{右值} \quad (\text{允许}) $$
$$ \text{右值} \xrightarrow{\text{赋值}} \text{左值} \quad (\text{禁止}) $$
main.py
TERMINALbash — 80x24
> Ready. Click "Run" to execute.
>
QUESTION 1
Which of the following best describes an lvalue?
A temporary result of a calculation.
An expression that yields an object with a persistent memory identity.
A literal constant like 3.14.
Any value that appears on the right side of an assignment.
✅ Correct!
Correct! Lvalues represent 'locatable' objects that reside in memory.❌ Incorrect
Lvalues are about identity (memory address). Literals and temporary results are typically rvalues.QUESTION 2
In the expression
dval = ival = 0;, why is 0 considered an rvalue?Because it is an integer.
Because it is on the far right of the expression.
Because it is a literal constant with no persistent memory address.
Because it is assigned to
pi.✅ Correct!
Exactly. Literals are values without a user-accessible memory identity.❌ Incorrect
The position doesn't determine lvalue/rvalue status; the nature of the expression (identity vs. value) does.QUESTION 3
True or False: You can use an rvalue where an lvalue is required.
True
False
✅ Correct!
False is correct. Operators like assignment (=) and address-of (&) require lvalues.❌ Incorrect
Rvalues cannot be used when the compiler needs a specific memory location to write to or point at.QUESTION 4
What happens when you use an lvalue in a context that requires an rvalue?
A compile-time error occurs.
The compiler performs an lvalue-to-rvalue conversion.
The memory address of the lvalue is used as the value.
The lvalue is deleted from memory.
✅ Correct!
The compiler simply fetches the value stored at that identity to use in the expression.❌ Incorrect
C++ is designed to allow lvalues to be used as rvalues seamlessly.QUESTION 5
Which of these expressions is an lvalue?
42x + y (where x and y are ints)std::string("hello")A variable name like
myVar✅ Correct!
Variable names are the most common lvalues because they refer directly to a persistent object.❌ Incorrect
Literals, arithmetic results, and temporary objects are rvalues.Comprehensive Expression Analysis
Applying Lvalue/Rvalue theory to Exercise 5.23 and 4.2
As a C++ developer, you must evaluate how expressions are grouped and whether their operands are valid based on their identity and value types. Consider the following definitions: int i; double d; const string *ps; char *pc; void *pv; vector<int> vec = {10, 20};
Q
1. [Exercise 5.23] Provide a program that safely reads two integers and prints the result of their division. What role do lvalues play here?
Solution:
Model Solution: cpp int n1, n2; if (std::cin >> n1 >> n2) { if (n2 != 0) std::cout << n1 / n2 << std::endl; else std::cerr << "Division by zero!" << std::endl; } In this program, `n1` and `n2` are lvalues used to store input. In the expression `n1 / n2`, they undergo lvalue-to-rvalue conversion to provide their contents for the arithmetic operation.
Model Solution: cpp int n1, n2; if (std::cin >> n1 >> n2) { if (n2 != 0) std::cout << n1 / n2 << std::endl; else std::cerr << "Division by zero!" << std::endl; } In this program, `n1` and `n2` are lvalues used to store input. In the expression `n1 / n2`, they undergo lvalue-to-rvalue conversion to provide their contents for the arithmetic operation.
Q
2. [Exercise 4.2] Parenthesize the expressions `* vec.begin()` and `* vec.begin() + 1`. Identify which parts are lvalues.
Solution:
Parenthesization: (a) `*(vec.begin())`: The `.` operator has higher precedence than `*`. `vec.begin()` returns an iterator (rvalue), and dereferencing it yields an lvalue (the first element of the vector). (b) `(*(vec.begin())) + 1`: The addition occurs after dereferencing. The result of the addition is an rvalue (a temporary numerical result).
Parenthesization: (a) `*(vec.begin())`: The `.` operator has higher precedence than `*`. `vec.begin()` returns an iterator (rvalue), and dereferencing it yields an lvalue (the first element of the vector). (b) `(*(vec.begin())) + 1`: The addition occurs after dereferencing. The result of the addition is an rvalue (a temporary numerical result).
Q
3. [Theory Depth] Why does `&42` fail while `&ival` succeeds?
Solution:
The address-of operator (`&`) requires an lvalue operand. `42` is a literal rvalue with no persistent location in memory to point to. `ival` is an lvalue representing a specific, identifiable memory address, so the operator can successfully return that address.
The address-of operator (`&`) requires an lvalue operand. `42` is a literal rvalue with no persistent location in memory to point to. `ival` is an lvalue representing a specific, identifiable memory address, so the operator can successfully return that address.